home *** CD-ROM | disk | FTP | other *** search
/ Nebula 2 / Nebula Two.iso / SourceCode / Palettes / OOPSPalette / OOPSTimer.m < prev    next >
Text File  |  1995-06-12  |  5KB  |  297 lines
  1. //Release 0.7  Copyright ª1993 by Kjell Nilsson, OOPS - ObjectWareHouse.  All Rights Reserved.
  2.  
  3. #import "OOPSTimer.h"
  4.  
  5. extern void makeItHappen(DPSTimedEntry te, double timeNow, void *data);
  6.  
  7. @implementation OOPSTimer
  8.  
  9. /*------------------ Private Methods ---------------------------------------*/
  10.  
  11. - sendAction:(DPSTimedEntry)te
  12. {
  13.     if (te!=_timer) return nil;
  14.     if (_action && _target) {
  15.         if ([_target respondsTo:_action]) {
  16.             [_target perform:_action with:self];
  17.         }
  18.     }
  19.     if (numberOfRepeatsLeft == 1 ) {
  20.         if (_stopAction && _target) {
  21.             if ([_target respondsTo:_stopAction]) {
  22.                 [_target perform:_stopAction with:self];
  23.             }
  24.         }
  25.         [self stopTimer:self];
  26.     } else {
  27.         numberOfRepeatsLeft--;
  28.     }
  29.     return self;
  30. }
  31. /*------------------ Public Methods ----------------------------------------*/
  32.  
  33. - init
  34. {
  35.     [super init];
  36.     _target = nil;
  37.     tag = 0;
  38.     _auto = NO;
  39.     _action = NULL;
  40.     _timer = NULL;
  41.     _paused = NO;
  42.     repeatTimeInterval = 1.0;    
  43.     numberOfRepeats = 0;                  // Will last forever
  44.     numberOfRepeatsLeft = 0;                 
  45.     [self setPriority:NX_BASETHRESHOLD];
  46.     return self;
  47. }
  48.  
  49. - initRepeatTimeInterval:(float)aRepeatTimeInterval
  50. {
  51.     [self init];
  52.     [self setRepeatTimeInterval:aRepeatTimeInterval];
  53.     return self;
  54. }
  55.  
  56. - initRepeatTimeInterval:(float)aRepeatTimeInterval target:aTarget action:(SEL)aSelector
  57. {
  58.     [self init];
  59.     [self setRepeatTimeInterval:aRepeatTimeInterval];
  60.     [self setTarget:aTarget];
  61.     [self setAction:aSelector];
  62.     return self;
  63. }
  64.  
  65. - free
  66. {
  67.     if (_timer) {
  68.         [self stopTimer:self];
  69.     }
  70.     return [super free];
  71. }
  72.  
  73. - awake
  74. {
  75.     [super awake];
  76.     if (_auto) {
  77.         [self startTimer:self];
  78.     }
  79.     return self;
  80. }
  81.  
  82. - (int)priority
  83. {
  84.     return priority;
  85. }
  86.  
  87. - setPriority:(int)aPriority
  88. {
  89.     if ((aPriority = 1) || (aPriority = 5) || (aPriority = 10)) {
  90.         priority = aPriority;
  91.     }
  92.     return self;
  93. }
  94.  
  95. - (float)repeatTimeInterval
  96. {
  97.     return repeatTimeInterval;
  98. }
  99.  
  100. - setRepeatTimeInterval:(float)someInterval
  101. {
  102.     repeatTimeInterval = someInterval;
  103.     return self;
  104. }
  105.  
  106. - (int)numberOfRepeats
  107. {
  108.     return numberOfRepeats;
  109. }
  110.  
  111. - (int)numberOfRepeatsLeft
  112. {
  113.     return numberOfRepeatsLeft;
  114. }
  115.  
  116. - setNumberOfRepeats:(int)someNumber;
  117. {
  118.     numberOfRepeats = someNumber;
  119.     return self;
  120. }
  121.  
  122. - (BOOL)autoStart
  123. {
  124.     return _auto;
  125. }
  126.  
  127. - setAutoStart:(BOOL)flag
  128. {
  129.     _auto = flag;
  130.     return self;
  131. }
  132.  
  133. - (BOOL)isRunning;
  134. {
  135.     if (_timer) {
  136.         return YES;
  137.     } else {
  138.         return NO;
  139.     }
  140. }
  141.  
  142. - target
  143. {
  144.     return _target;
  145. }
  146.  
  147. - setTarget:anObject
  148. {
  149.     _target = anObject;
  150.     return self;
  151. }
  152.  
  153. - (SEL)action
  154. {
  155.     return _action;
  156. }
  157.  
  158. - setAction:(SEL)aSelector
  159. {
  160.     _action = aSelector;
  161.     return self;
  162. }
  163.  
  164. - (SEL)stopAction
  165. {
  166.     return _stopAction;
  167. }
  168.  
  169. - setStopAction:(SEL)aSelector
  170. {
  171.     _stopAction = aSelector;
  172.     return self;
  173. }
  174.  
  175. - (int)tag
  176. {
  177.     return tag;
  178. }
  179.  
  180. - setTag:(int)anInt
  181. {
  182.     tag = anInt;
  183.     return self;
  184. }
  185.  
  186. - takeRepeatTimeIntervalFrom:sender
  187. {
  188.     repeatTimeInterval = [sender floatValue];    
  189.     if ([self isRunning]) {
  190.         [self pauseTimer:sender];
  191.         [self pauseTimer:sender];
  192.     }
  193.     return self;
  194. }
  195.  
  196. - takeNumberOfRepeatsFrom:sender;
  197. {
  198.     numberOfRepeats = [sender intValue];    
  199.     return self;
  200. }
  201.  
  202. - startTimer:sender
  203. {
  204.     numberOfRepeatsLeft = numberOfRepeats;
  205.     _paused = NO;
  206.     if (!_timer){
  207.         _timer = DPSAddTimedEntry(repeatTimeInterval, &makeItHappen, self, priority);
  208.     }
  209.     return self;
  210. }
  211.  
  212. - pauseTimer:sender
  213. {
  214.     if (_timer) {
  215.         DPSRemoveTimedEntry(_timer); 
  216.         _timer = NULL;
  217.         _paused = YES;
  218.     } else {
  219.         if (_paused) {
  220.             _timer = DPSAddTimedEntry(repeatTimeInterval, &makeItHappen, self, priority);
  221.             _paused = NO;
  222.         }
  223.     }
  224.     return self;
  225. }
  226.  
  227. - stopTimer:sender
  228. {
  229.     _paused = NO;
  230.     if (_timer) {
  231.         DPSRemoveTimedEntry(_timer);
  232.         _timer = NULL;
  233.     }
  234.     return self;
  235. }
  236.  
  237. - read: (NXTypedStream*) stream
  238. {
  239.     [super read: stream];
  240.     NXReadType (stream, "f", &repeatTimeInterval);
  241.     NXReadType (stream, "i", &numberOfRepeats);
  242.     NXReadType (stream, "i", &numberOfRepeatsLeft);
  243.     NXReadType (stream, "i", &priority);
  244.     NXReadType (stream, "i", &tag);
  245.     NXReadType (stream, "c", &_auto);
  246.     _target = NXReadObject (stream);
  247.     NXReadType (stream, ":", &_action);
  248.     NXReadType (stream, ":", &_stopAction);
  249.     return self;
  250. }
  251.  
  252. - write: (NXTypedStream*) stream
  253. {
  254.     [super write: stream];
  255.     NXWriteType (stream, "f", &repeatTimeInterval);
  256.     NXWriteType (stream, "i", &numberOfRepeats);
  257.     NXWriteType (stream, "i", &numberOfRepeatsLeft);
  258.     NXWriteType (stream, "i", &priority);
  259.     NXWriteType (stream, "i", &tag);
  260.     NXWriteType (stream, "c", &_auto);
  261.     NXWriteObjectReference (stream, _target);
  262.     NXWriteType (stream, ":", &_action);
  263.     NXWriteType (stream, ":", &_stopAction);
  264.     return self;
  265. }
  266.  
  267. // IBSupport
  268.  
  269. - (const char *)getInspectorClassName 
  270. {
  271.      return "OOPSTimerInspector"; 
  272. }
  273.  
  274. - (NXImage *)getIBImage
  275. {
  276.     char        buf[MAXPATHLEN + 1];
  277.     NXBundle   *bundle;
  278.     NXImage    *image;
  279.  
  280.     image = [[NXImage alloc] init];
  281.  
  282.     bundle = [NXBundle bundleForClass:[self class]];
  283.     if ( [bundle getPath:buf forResource:"Timer" ofType:"tiff"] ) {
  284.         image = [[NXImage alloc] initFromFile:buf];
  285.     }
  286.     return(image);
  287. }
  288.  
  289. @end
  290.  
  291.  
  292. void makeItHappen(DPSTimedEntry te, double timeNow, void *data)
  293. {
  294.     [(id)data sendAction:te];
  295. }
  296.  
  297.